/*
 * This file is part of "JTA - Telnet/SSH for the JAVA(tm) platform".
 *
 * (c) Matthias L. Jugel, Marcus Mei�ner 1996-2005. All Rights Reserved.
 *
 * Please visit http://javatelnet.org/ for updates and contact.
 *
 * --LICENSE NOTICE--
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 * --LICENSE NOTICE--
 *
 */

package de.mud.terminal;

import java.util.Arrays;

/**
 * Implementation of a Video Display Unit (VDU) buffer. This class contains all
 * methods to manipulate the buffer that stores characters and their attributes
 * as well as the regions displayed.
 * 
 * @author Matthias L. Jugel, Marcus Meißner
 * @version $Id: VDUBuffer.java 503 2005-10-24 07:34:13Z marcus $
 */
public class VDUBuffer {

	/** The current version id tag */
	public final static String ID = "$Id: VDUBuffer.java 503 2005-10-24 07:34:13Z marcus $";

	/** Enable debug messages. */
	public final static int debug = 0;

	public int height, width; /* rows and columns */
	public boolean[] update; /* contains the lines that need update */
	public char[][] charArray; /* contains the characters */
	public int[][] charAttributes; /* contains character attrs */
	public int bufSize;
	public int maxBufSize; /* buffer sizes */
	public int screenBase; /* the actual screen start */
	public int windowBase; /* where the start displaying */
	public int scrollMarker; /* marks the last line inserted */

	private int topMargin; /* top scroll margin */
	private int bottomMargin; /* bottom scroll margin */

	// cursor variables
	protected boolean showcursor = true;
	protected int cursorX, cursorY;

	/** Scroll up when inserting a line. */
	public final static boolean SCROLL_UP = false;
	/** Scroll down when inserting a line. */
	public final static boolean SCROLL_DOWN = true;

	/*
	 * Attributes bit-field usage:
	 * 
	 * 8421 8421 8421 8421 8421 8421 8421 8421 |||| |||| |||| |||| |||| ||||
	 * |||| |||`- Bold |||| |||| |||| |||| |||| |||| |||| ||`-- Underline ||||
	 * |||| |||| |||| |||| |||| |||| |`--- Invert |||| |||| |||| |||| |||| ||||
	 * |||| `---- Low |||| |||| |||| |||| |||| |||| |||`------ Invisible ||||
	 * |||| |||| |||| ||`+-++++-+++------- Foreground Color |||| ||||
	 * |`++-++++-++------------------ Background Color |||| ||||
	 * `----------------------------- Fullwidth character
	 * `+++-++++------------------------------- Reserved for future use
	 */

	/** Make character normal. */
	public final static int NORMAL = 0x00;
	/** Make character bold. */
	public final static int BOLD = 0x01;
	/** Underline character. */
	public final static int UNDERLINE = 0x02;
	/** Invert character. */
	public final static int INVERT = 0x04;
	/** Lower intensity character. */
	public final static int LOW = 0x08;
	/** Invisible character. */
	public final static int INVISIBLE = 0x10;
	/** Unicode full-width character (CJK, et al.) */
	public final static int FULLWIDTH = 0x8000000;

	/** how much to left shift the foreground color */
	public final static int COLOR_FG_SHIFT = 5;
	/** how much to left shift the background color */
	public final static int COLOR_BG_SHIFT = 14;
	/** color mask */
	public final static int COLOR = 0x7fffe0; /*
											 * 0000 0000 0111 1111 1111 1111
											 * 1110 0000
											 */
	/** foreground color mask */
	public final static int COLOR_FG = 0x3fe0; /*
												 * 0000 0000 0000 0000 0011 1111
												 * 1110 0000
												 */
	/** background color mask */
	public final static int COLOR_BG = 0x7fc000; /*
												 * 0000 0000 0111 1111 1100 0000
												 * 0000 0000
												 */

	/**
	 * Create a new video display buffer with the passed width and height in
	 * characters.
	 * 
	 * @param width
	 *            the length of the character lines
	 * @param height
	 *            the amount of lines on the screen
	 */
	public VDUBuffer(int width, int height) {
		// set the display screen size
		setScreenSize(width, height, false);
	}

	/**
	 * Create a standard video display buffer with 80 columns and 24 lines.
	 */
	public VDUBuffer() {
		this(80, 24);
	}

	/**
	 * Put a character on the screen with normal font and outline. The character
	 * previously on that position will be overwritten. You need to call
	 * redraw() to update the screen.
	 * 
	 * @param c
	 *            x-coordinate (column)
	 * @param l
	 *            y-coordinate (line)
	 * @param ch
	 *            the character to show on the screen
	 * @see #insertChar
	 * @see #deleteChar
	 * @see #redraw
	 */
	public void putChar(int c, int l, char ch) {
		putChar(c, l, ch, NORMAL);
	}

	/**
	 * Put a character on the screen with specific font and outline. The
	 * character previously on that position will be overwritten. You need to
	 * call redraw() to update the screen.
	 * 
	 * @param c
	 *            x-coordinate (column)
	 * @param l
	 *            y-coordinate (line)
	 * @param ch
	 *            the character to show on the screen
	 * @param attributes
	 *            the character attributes
	 * @see #BOLD
	 * @see #UNDERLINE
	 * @see #INVERT
	 * @see #INVISIBLE
	 * @see #NORMAL
	 * @see #LOW
	 * @see #insertChar
	 * @see #deleteChar
	 * @see #redraw
	 */

	public void putChar(int c, int l, char ch, int attributes) {
		charArray[screenBase + l][c] = ch;
		charAttributes[screenBase + l][c] = attributes;
		if (l < height)
			update[l + 1] = true;
	}

	/**
	 * Get the character at the specified position.
	 * 
	 * @param c
	 *            x-coordinate (column)
	 * @param l
	 *            y-coordinate (line)
	 * @see #putChar
	 */
	public char getChar(int c, int l) {
		return charArray[screenBase + l][c];
	}

	/**
	 * Get the attributes for the specified position.
	 * 
	 * @param c
	 *            x-coordinate (column)
	 * @param l
	 *            y-coordinate (line)
	 * @see #putChar
	 */
	public int getAttributes(int c, int l) {
		return charAttributes[screenBase + l][c];
	}

	/**
	 * Insert a character at a specific position on the screen. All character
	 * right to from this position will be moved one to the right. You need to
	 * call redraw() to update the screen.
	 * 
	 * @param c
	 *            x-coordinate (column)
	 * @param l
	 *            y-coordinate (line)
	 * @param ch
	 *            the character to insert
	 * @param attributes
	 *            the character attributes
	 * @see #BOLD
	 * @see #UNDERLINE
	 * @see #INVERT
	 * @see #INVISIBLE
	 * @see #NORMAL
	 * @see #LOW
	 * @see #putChar
	 * @see #deleteChar
	 * @see #redraw
	 */
	public void insertChar(int c, int l, char ch, int attributes) {
		System.arraycopy(charArray[screenBase + l], c, charArray[screenBase + l], c + 1, width - c
				- 1);
		System.arraycopy(charAttributes[screenBase + l], c, charAttributes[screenBase + l], c + 1,
				width - c - 1);
		putChar(c, l, ch, attributes);
	}

	/**
	 * Delete a character at a given position on the screen. All characters
	 * right to the position will be moved one to the left. You need to call
	 * redraw() to update the screen.
	 * 
	 * @param c
	 *            x-coordinate (column)
	 * @param l
	 *            y-coordinate (line)
	 * @see #putChar
	 * @see #insertChar
	 * @see #redraw
	 */
	public void deleteChar(int c, int l) {
		if (c < width - 1) {
			System.arraycopy(charArray[screenBase + l], c + 1, charArray[screenBase + l], c, width
					- c - 1);
			System.arraycopy(charAttributes[screenBase + l], c + 1, charAttributes[screenBase + l],
					c, width - c - 1);
		}
		putChar(width - 1, l, (char) 0);
	}

	/**
	 * Put a String at a specific position. Any characters previously on that
	 * position will be overwritten. You need to call redraw() for screen
	 * update.
	 * 
	 * @param c
	 *            x-coordinate (column)
	 * @param l
	 *            y-coordinate (line)
	 * @param s
	 *            the string to be shown on the screen
	 * @see #BOLD
	 * @see #UNDERLINE
	 * @see #INVERT
	 * @see #INVISIBLE
	 * @see #NORMAL
	 * @see #LOW
	 * @see #putChar
	 * @see #insertLine
	 * @see #deleteLine
	 * @see #redraw
	 */
	public void putString(int c, int l, String s) {
		putString(c, l, s, NORMAL);
	}

	/**
	 * Put a String at a specific position giving all characters the same
	 * attributes. Any characters previously on that position will be
	 * overwritten. You need to call redraw() to update the screen.
	 * 
	 * @param c
	 *            x-coordinate (column)
	 * @param l
	 *            y-coordinate (line)
	 * @param s
	 *            the string to be shown on the screen
	 * @param attributes
	 *            character attributes
	 * @see #BOLD
	 * @see #UNDERLINE
	 * @see #INVERT
	 * @see #INVISIBLE
	 * @see #NORMAL
	 * @see #LOW
	 * @see #putChar
	 * @see #insertLine
	 * @see #deleteLine
	 * @see #redraw
	 */
	public void putString(int c, int l, String s, int attributes) {
		for (int i = 0; i < s.length() && c + i < width; i++)
			putChar(c + i, l, s.charAt(i), attributes);
	}

	/**
	 * Insert a blank line at a specific position. The current line and all
	 * previous lines are scrolled one line up. The top line is lost. You need
	 * to call redraw() to update the screen.
	 * 
	 * @param l
	 *            the y-coordinate to insert the line
	 * @see #deleteLine
	 * @see #redraw
	 */
	public void insertLine(int l) {
		insertLine(l, 1, SCROLL_UP);
	}

	/**
	 * Insert blank lines at a specific position. You need to call redraw() to
	 * update the screen
	 * 
	 * @param l
	 *            the y-coordinate to insert the line
	 * @param n
	 *            amount of lines to be inserted
	 * @see #deleteLine
	 * @see #redraw
	 */
	public void insertLine(int l, int n) {
		insertLine(l, n, SCROLL_UP);
	}

	/**
	 * Insert a blank line at a specific position. Scroll text according to the
	 * argument. You need to call redraw() to update the screen
	 * 
	 * @param l
	 *            the y-coordinate to insert the line
	 * @param scrollDown
	 *            scroll down
	 * @see #deleteLine
	 * @see #SCROLL_UP
	 * @see #SCROLL_DOWN
	 * @see #redraw
	 */
	public void insertLine(int l, boolean scrollDown) {
		insertLine(l, 1, scrollDown);
	}

	/**
	 * Insert blank lines at a specific position. The current line and all
	 * previous lines are scrolled one line up. The top line is lost. You need
	 * to call redraw() to update the screen.
	 * 
	 * @param l
	 *            the y-coordinate to insert the line
	 * @param n
	 *            number of lines to be inserted
	 * @param scrollDown
	 *            scroll down
	 * @see #deleteLine
	 * @see #SCROLL_UP
	 * @see #SCROLL_DOWN
	 * @see #redraw
	 */
	public synchronized void insertLine(int l, int n, boolean scrollDown) {
		char cbuf[][] = null;
		int abuf[][] = null;
		int offset = 0;
		int oldBase = screenBase;

		int newScreenBase = screenBase;
		int newWindowBase = windowBase;
		int newBufSize = bufSize;

		if (l > bottomMargin) /*
							 * We do not scroll below bottom margin (below the
							 * scrolling region).
							 */
			return;
		int top = (l < topMargin ? 0
				: (l > bottomMargin ? (bottomMargin + 1 < height ? bottomMargin + 1 : height - 1)
						: topMargin));
		int bottom = (l > bottomMargin ? height - 1
				: (l < topMargin ? (topMargin > 0 ? topMargin - 1 : 0) : bottomMargin));

		// System.out.println("l is "+l+", top is "+top+", bottom is "+bottom+", bottomargin is "+bottomMargin+", topMargin is "+topMargin);

		if (scrollDown) {
			if (n > (bottom - top))
				n = (bottom - top);
			int size = bottom - l - (n - 1);
			if (size < 0)
				size = 0;
			cbuf = new char[size][];
			abuf = new int[size][];

			System.arraycopy(charArray, oldBase + l, cbuf, 0, bottom - l - (n - 1));
			System.arraycopy(charAttributes, oldBase + l, abuf, 0, bottom - l - (n - 1));
			System.arraycopy(cbuf, 0, charArray, oldBase + l + n, bottom - l - (n - 1));
			System.arraycopy(abuf, 0, charAttributes, oldBase + l + n, bottom - l - (n - 1));
			cbuf = charArray;
			abuf = charAttributes;
		} else {
			try {
				if (n > (bottom - top) + 1)
					n = (bottom - top) + 1;
				if (bufSize < maxBufSize) {
					if (bufSize + n > maxBufSize) {
						offset = n - (maxBufSize - bufSize);
						scrollMarker += offset;
						newBufSize = maxBufSize;
						newScreenBase = maxBufSize - height - 1;
						newWindowBase = screenBase;
					} else {
						scrollMarker += n;
						newScreenBase += n;
						newWindowBase += n;
						newBufSize += n;
					}

					cbuf = new char[newBufSize][];
					abuf = new int[newBufSize][];
				} else {
					offset = n;
					cbuf = charArray;
					abuf = charAttributes;
				}
				// copy anything from the top of the buffer (+offset) to the new
				// top
				// up to the screenBase.
				if (oldBase > 0) {
					System.arraycopy(charArray, offset, cbuf, 0, oldBase - offset);
					System.arraycopy(charAttributes, offset, abuf, 0, oldBase - offset);
				}
				// copy anything from the top of the screen (screenBase) up to
				// the
				// topMargin to the new screen
				if (top > 0) {
					System.arraycopy(charArray, oldBase, cbuf, newScreenBase, top);
					System.arraycopy(charAttributes, oldBase, abuf, newScreenBase, top);
				}
				// copy anything from the topMargin up to the amount of lines
				// inserted
				// to the gap left over between scrollback buffer and screenBase
				if (oldBase >= 0) {
					System.arraycopy(charArray, oldBase + top, cbuf, oldBase - offset, n);
					System.arraycopy(charAttributes, oldBase + top, abuf, oldBase - offset, n);
				}
				// copy anything from topMargin + n up to the line linserted to
				// the
				// topMargin
				System.arraycopy(charArray, oldBase + top + n, cbuf, newScreenBase + top, l - top
						- (n - 1));
				System.arraycopy(charAttributes, oldBase + top + n, abuf, newScreenBase + top, l
						- top - (n - 1));
				//
				// copy the all lines next to the inserted to the new buffer
				if (l < height - 1) {
					System.arraycopy(charArray, oldBase + l + 1, cbuf, newScreenBase + l + 1,
							(height - 1) - l);
					System.arraycopy(charAttributes, oldBase + l + 1, abuf, newScreenBase + l + 1,
							(height - 1) - l);
				}
			} catch (ArrayIndexOutOfBoundsException e) {
				// this should not happen anymore, but I will leave the code
				// here in case something happens anyway. That code above is
				// so complex I always have a hard time understanding what
				// I did, even though there are comments
				System.err.println("*** Error while scrolling up:");
				System.err.println("--- BEGIN STACK TRACE ---");
				e.printStackTrace();
				System.err.println("--- END STACK TRACE ---");
				System.err.println("bufSize=" + bufSize + ", maxBufSize=" + maxBufSize);
				System.err.println("top=" + top + ", bottom=" + bottom);
				System.err.println("n=" + n + ", l=" + l);
				System.err.println("screenBase=" + screenBase + ", windowBase=" + windowBase);
				System.err.println("newScreenBase=" + newScreenBase + ", newWindowBase="
						+ newWindowBase);
				System.err.println("oldBase=" + oldBase);
				System.err.println("size.width=" + width + ", size.height=" + height);
				System.err.println("abuf.length=" + abuf.length + ", cbuf.length=" + cbuf.length);
				System.err.println("*** done dumping debug information");
			}
		}

		// this is a little helper to mark the scrolling
		scrollMarker -= n;

		for (int i = 0; i < n; i++) {
			cbuf[(newScreenBase + l) + (scrollDown ? i : -i)] = new char[width];
			Arrays.fill(cbuf[(newScreenBase + l) + (scrollDown ? i : -i)], ' ');
			abuf[(newScreenBase + l) + (scrollDown ? i : -i)] = new int[width];
		}

		charArray = cbuf;
		charAttributes = abuf;
		screenBase = newScreenBase;
		windowBase = newWindowBase;
		bufSize = newBufSize;

		if (scrollDown)
			markLine(l, bottom - l + 1);
		else
			markLine(top, l - top + 1);

		display.updateScrollBar();
	}

	/**
	 * Delete a line at a specific position. Subsequent lines will be scrolled
	 * up to fill the space and a blank line is inserted at the end of the
	 * screen.
	 * 
	 * @param l
	 *            the y-coordinate to insert the line
	 * @see #deleteLine
	 */
	public void deleteLine(int l) {
		int bottom = (l > bottomMargin ? height - 1
				: (l < topMargin ? topMargin : bottomMargin + 1));
		int numRows = bottom - l - 1;

		char[] discardedChars = charArray[screenBase + l];
		int[] discardedAttributes = charAttributes[screenBase + l];

		if (numRows > 0) {
			System.arraycopy(charArray, screenBase + l + 1, charArray, screenBase + l, numRows);
			System.arraycopy(charAttributes, screenBase + l + 1, charAttributes, screenBase + l,
					numRows);
		}

		int newBottomRow = screenBase + bottom - 1;
		charArray[newBottomRow] = discardedChars;
		charAttributes[newBottomRow] = discardedAttributes;
		Arrays.fill(charArray[newBottomRow], ' ');
		Arrays.fill(charAttributes[newBottomRow], 0);

		markLine(l, bottom - l);
	}

	/**
	 * Delete a rectangular portion of the screen. You need to call redraw() to
	 * update the screen.
	 * 
	 * @param c
	 *            x-coordinate (column)
	 * @param l
	 *            y-coordinate (row)
	 * @param w
	 *            with of the area in characters
	 * @param h
	 *            height of the area in characters
	 * @param curAttr
	 *            attribute to fill
	 * @see #deleteChar
	 * @see #deleteLine
	 * @see #redraw
	 */
	public void deleteArea(int c, int l, int w, int h, int curAttr) {
		int endColumn = c + w;
		int targetRow = screenBase + l;
		for (int i = 0; i < h && l + i < height; i++) {
			Arrays.fill(charAttributes[targetRow], c, endColumn, curAttr);
			Arrays.fill(charArray[targetRow], c, endColumn, ' ');
			targetRow++;
		}
		markLine(l, h);
	}

	/**
	 * Delete a rectangular portion of the screen. You need to call redraw() to
	 * update the screen.
	 * 
	 * @param c
	 *            x-coordinate (column)
	 * @param l
	 *            y-coordinate (row)
	 * @param w
	 *            with of the area in characters
	 * @param h
	 *            height of the area in characters
	 * @see #deleteChar
	 * @see #deleteLine
	 * @see #redraw
	 */
	public void deleteArea(int c, int l, int w, int h) {
		deleteArea(c, l, w, h, 0);
	}

	/**
	 * Sets whether the cursor is visible or not.
	 * 
	 * @param doshow
	 */
	public void showCursor(boolean doshow) {
		showcursor = doshow;
	}

	/**
	 * Check whether the cursor is currently visible.
	 * 
	 * @return visibility
	 */
	public boolean isCursorVisible() {
		return showcursor;
	}

	/**
	 * Puts the cursor at the specified position.
	 * 
	 * @param c
	 *            column
	 * @param l
	 *            line
	 */
	public void setCursorPosition(int c, int l) {
		cursorX = c;
		cursorY = l;
	}

	/**
	 * Get the current column of the cursor position.
	 */
	public int getCursorColumn() {
		return cursorX;
	}

	/**
	 * Get the current line of the cursor position.
	 */
	public int getCursorRow() {
		return cursorY;
	}

	/**
	 * Set the current window base. This allows to view the scrollback buffer.
	 * 
	 * @param line
	 *            the line where the screen window starts
	 * @see #setBufferSize
	 * @see #getBufferSize
	 */
	public void setWindowBase(int line) {
		if (line > screenBase)
			line = screenBase;
		else if (line < 0)
			line = 0;
		windowBase = line;
		update[0] = true;
		redraw();
	}

	/**
	 * Get the current window base.
	 * 
	 * @see #setWindowBase
	 */
	public int getWindowBase() {
		return windowBase;
	}

	/**
	 * Set the scroll margins simultaneously. If they're out of bounds, trim
	 * them.
	 * 
	 * @param l1
	 *            line that is the top
	 * @param l2
	 *            line that is the bottom
	 */
	public void setMargins(int l1, int l2) {
		if (l1 > l2)
			return;

		if (l1 < 0)
			l1 = 0;
		if (l2 >= height)
			l2 = height - 1;

		topMargin = l1;
		bottomMargin = l2;
	}

	/**
	 * Set the top scroll margin for the screen. If the current bottom margin is
	 * smaller it will become the top margin and the line will become the bottom
	 * margin.
	 * 
	 * @param l
	 *            line that is the margin
	 */
	public void setTopMargin(int l) {
		if (l > bottomMargin) {
			topMargin = bottomMargin;
			bottomMargin = l;
		} else
			topMargin = l;
		if (topMargin < 0)
			topMargin = 0;
		if (bottomMargin >= height)
			bottomMargin = height - 1;
	}

	/**
	 * Get the top scroll margin.
	 */
	public int getTopMargin() {
		return topMargin;
	}

	/**
	 * Set the bottom scroll margin for the screen. If the current top margin is
	 * bigger it will become the bottom margin and the line will become the top
	 * margin.
	 * 
	 * @param l
	 *            line that is the margin
	 */
	public void setBottomMargin(int l) {
		if (l < topMargin) {
			bottomMargin = topMargin;
			topMargin = l;
		} else
			bottomMargin = l;
		if (topMargin < 0)
			topMargin = 0;
		if (bottomMargin >= height)
			bottomMargin = height - 1;
	}

	/**
	 * Get the bottom scroll margin.
	 */
	public int getBottomMargin() {
		return bottomMargin;
	}

	/**
	 * Set scrollback buffer size.
	 * 
	 * @param amount
	 *            new size of the buffer
	 */
	public void setBufferSize(int amount) {
		if (amount < height)
			amount = height;
		if (amount < maxBufSize) {
			char cbuf[][] = new char[amount][width];
			int abuf[][] = new int[amount][width];
			int copyStart = bufSize - amount < 0 ? 0 : bufSize - amount;
			int copyCount = bufSize - amount < 0 ? bufSize : amount;
			if (charArray != null)
				System.arraycopy(charArray, copyStart, cbuf, 0, copyCount);
			if (charAttributes != null)
				System.arraycopy(charAttributes, copyStart, abuf, 0, copyCount);
			charArray = cbuf;
			charAttributes = abuf;
			bufSize = copyCount;
			screenBase = bufSize - height;
			windowBase = screenBase;
		}
		maxBufSize = amount;

		update[0] = true;
		redraw();
	}

	/**
	 * Retrieve current scrollback buffer size.
	 * 
	 * @see #setBufferSize
	 */
	public int getBufferSize() {
		return bufSize;
	}

	/**
	 * Retrieve maximum buffer Size.
	 * 
	 * @see #getBufferSize
	 */
	public int getMaxBufferSize() {
		return maxBufSize;
	}

	/**
	 * Change the size of the screen. This will include adjustment of the
	 * scrollback buffer.
	 * 
	 * @param w
	 *            of the screen
	 * @param h
	 *            of the screen
	 */
	public void setScreenSize(int w, int h, boolean broadcast) {
		char cbuf[][];
		int abuf[][];
		int maxSize = bufSize;

		if (w < 1 || h < 1)
			return;

		if (debug > 0)
			System.err.println("VDU: screen size [" + w + "," + h + "]");

		if (h > maxBufSize)
			maxBufSize = h;

		if (h > bufSize) {
			bufSize = h;
			screenBase = 0;
			windowBase = 0;
		}

		if (windowBase + h >= bufSize)
			windowBase = bufSize - h;

		if (screenBase + h >= bufSize)
			screenBase = bufSize - h;

		cbuf = new char[bufSize][w];
		abuf = new int[bufSize][w];

		for (int i = 0; i < bufSize; i++) {
			Arrays.fill(cbuf[i], ' ');
		}

		if (bufSize < maxSize)
			maxSize = bufSize;

		int rowLength;
		if (charArray != null && charAttributes != null) {
			for (int i = 0; i < maxSize && charArray[i] != null; i++) {
				rowLength = charArray[i].length;
				System.arraycopy(charArray[i], 0, cbuf[i], 0, w < rowLength ? w : rowLength);
				System.arraycopy(charAttributes[i], 0, abuf[i], 0, w < rowLength ? w : rowLength);
			}
		}

		int C = getCursorColumn();
		if (C < 0)
			C = 0;
		else if (C >= width)
			C = width - 1;

		int R = getCursorRow();
		if (R < 0)
			R = 0;
		else if (R >= height)
			R = height - 1;

		setCursorPosition(C, R);

		charArray = cbuf;
		charAttributes = abuf;
		width = w;
		height = h;
		topMargin = 0;
		bottomMargin = h - 1;
		update = new boolean[h + 1];
		update[0] = true;
		/*
		 * FIXME: ??? if(resizeStrategy == RESIZE_FONT) setBounds(getBounds());
		 */
	}

	/**
	 * Get amount of rows on the screen.
	 */
	public int getRows() {
		return height;
	}

	/**
	 * Get amount of columns on the screen.
	 */
	public int getColumns() {
		return width;
	}

	/**
	 * Mark lines to be updated with redraw().
	 * 
	 * @param l
	 *            starting line
	 * @param n
	 *            amount of lines to be updated
	 * @see #redraw
	 */
	public void markLine(int l, int n) {
		for (int i = 0; (i < n) && (l + i < height); i++)
			update[l + i + 1] = true;
	}

	// private static int checkBounds(int value, int lower, int upper) {
	// if (value < lower)
	// return lower;
	// else if (value > upper)
	// return upper;
	// else
	// return value;
	// }

	/** a generic display that should redraw on demand */
	protected VDUDisplay display;

	public void setDisplay(VDUDisplay display) {
		this.display = display;
	}

	/**
	 * Trigger a redraw on the display.
	 */
	protected void redraw() {
		if (display != null)
			display.redraw();
	}
}
